home *** CD-ROM | disk | FTP | other *** search
/ The Games Machine 80 / XENIATGM80.iso / Goodies / Blood 2 / Source / data.z / Credits.cpp < prev    next >
C/C++ Source or Header  |  1999-04-02  |  19KB  |  996 lines
  1. /****************************************************************************
  2. ;
  3. ;     MODULE:        Credits (.CPP)
  4. ;
  5. ;    PURPOSE:        Credits class
  6. ;
  7. ;    HISTORY:        07/24/98 [blg] This file was created
  8. ;
  9. ;    COMMENT:        Copyright (c) 1998, Monolith Productions Inc.
  10. ;
  11. ****************************************************************************/
  12.  
  13.  
  14. // Includes...
  15.  
  16. #include "client_de.h"
  17. #include "Credits.h"
  18. #include "BloodClientShell.h"
  19. #include "vkdefs.h"
  20. #include <stdio.h>
  21. #include "CreditsWin.h"
  22. #include "ClientRes.h"
  23. #include "mbstring.h"
  24.  
  25.  
  26. // Macros...
  27.  
  28. #define TERM_COLOR(hC)    if (m_pClientDE && hC) { m_pClientDE->DeleteColor(hC); hC = NULL; }
  29. #define TERM_FONT(hF)    if (m_pClientDE && hF) { m_pClientDE->DeleteFont(hF); hF = NULL; }
  30. #define TERM_STRING(hS)    if (m_pClientDE && hS) { m_pClientDE->FreeString(hS); hS = NULL; }
  31.  
  32.  
  33. // Statics...
  34.  
  35. int            CCredit::s_nFontHeight      = 0;
  36. int            CCredit::s_nFontSpacing     = 0;
  37. DDWORD        CCredit::s_dwScreenWidth    = 0;
  38. DDWORD        CCredit::s_dwScreenHeight   = 0;
  39. HDEFONT        CCredit::s_hFont            = NULL;
  40. HSURFACE    CCredit::s_hScreen          = NULL;
  41. CClientDE*    CCredit::s_pClientDE        = NULL;
  42. float        CCredit::s_fDefaultHoldTime = 2.0f;
  43. float        CCredit::s_fDefaultOutTime  = 0.6f;
  44. DBOOL        CCredit::s_bClearScreen     = DTRUE;
  45.  
  46. DFLOAT        CCredits::s_fSpeed = DEF_CREDITS_SPEED;
  47.  
  48. DBOOL        s_bPause = DFALSE;
  49.  
  50.  
  51. // Functions...
  52.  
  53. // ----------------------------------------------------------------------- //
  54. //
  55. //    ROUTINE:    CCredit::Init
  56. //
  57. //    PURPOSE:    Initialization
  58. //
  59. // ----------------------------------------------------------------------- //
  60.  
  61. DBOOL CCredit::Init(CClientDE* pClientDE, char* sBuf)
  62. {
  63.     // Sanity checks...
  64.  
  65.     if (!pClientDE) return(DFALSE);
  66.     if (!sBuf) return(DFALSE);
  67.  
  68.  
  69.     // Set simple members...
  70.  
  71.     m_pClientDE = pClientDE;
  72.     m_nState    = CS_START;
  73.  
  74.     s_bPause    = DFALSE;
  75.  
  76.  
  77.     // Parse the text buffer and add each line as a seperate string...
  78.  
  79.     char sString[256];
  80.     int  i = 0;
  81.  
  82.     while (*sBuf)
  83.     {
  84.         if ((*sBuf == '\n') || (*sBuf == '\r') || (*sBuf == '\0'))
  85.         {
  86.             sString[i] = '\0';
  87.             AddString(sString); 
  88.             i = 0;
  89.  
  90.             while (((*sBuf == '\n') || (*sBuf == '\r'))) 
  91.             {
  92.                 sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
  93.             };
  94.         }
  95.         else
  96.         {
  97.             int nCount = _mbsnbcnt((const unsigned char*)sBuf,1);
  98.             memcpy(&sString[i], sBuf, nCount);
  99.             i += nCount;
  100.             sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
  101.         }
  102.     }
  103.  
  104.     sString[i] = '\0';
  105.     if (_mbstrlen(sString) > 0) AddString(sString);
  106.  
  107.  
  108.     // All done...
  109.  
  110.     return(DTRUE);
  111. }
  112.  
  113.  
  114. // ----------------------------------------------------------------------- //
  115. //
  116. //    ROUTINE:    CCredit::Term
  117. //
  118. //    PURPOSE:    Termination
  119. //
  120. // ----------------------------------------------------------------------- //
  121.  
  122. void CCredit::Term()
  123. {
  124.     for (int i = 0; i < MAX_CREDIT_STRINGS; i++)
  125.     {
  126.         TERM_STRING(m_aStrings[i]);
  127.     }
  128.  
  129.     Clear();
  130. }
  131.  
  132.  
  133. // ----------------------------------------------------------------------- //
  134. //
  135. //    ROUTINE:    CCredit::AddString
  136. //
  137. //    PURPOSE:    Adds a new string
  138. //
  139. // ----------------------------------------------------------------------- //
  140.  
  141. DBOOL CCredit::AddString(char* sString)
  142. {
  143.     // Sanity checks...
  144.  
  145.     if (!m_pClientDE) return(DFALSE);
  146.     if (!sString) return(DFALSE);
  147.     if (m_cStrings >= MAX_CREDIT_STRINGS) return(DFALSE);
  148.  
  149.  
  150.     // Check if this is a special command string...
  151.  
  152.     if (_mbsnbcmp((const unsigned char*)sString, (const unsigned char*)">TIME:", 6) == 0)
  153.     {
  154.         if (_mbstrlen(sString) > 6)
  155.         {
  156.             m_fHoldTime = (float)atof(&sString[6]);
  157.             return(DTRUE);
  158.         }
  159.     }
  160.  
  161.  
  162.     // Create a new string via the engine...
  163.  
  164.     HSTRING hString = m_pClientDE->CreateString(sString);
  165.     if (!hString) return(DFALSE);
  166.  
  167.     m_aStrings[m_cStrings++] = hString;
  168.  
  169.  
  170.     // All done...
  171.  
  172.     return(DTRUE);
  173. }
  174.  
  175.  
  176. // ----------------------------------------------------------------------- //
  177. //
  178. //    ROUTINE:    CCredit::SetStaticInfo
  179. //
  180. //    PURPOSE:    Sets all the static data that we'll need
  181. //
  182. // ----------------------------------------------------------------------- //
  183.  
  184. DBOOL CCredit::SetStaticInfo(CClientDE* pClientDE, int nMode, DBOOL bClearScreen)
  185. {
  186.     // Sanity checks...
  187.  
  188.     if (!pClientDE) return(DFALSE);
  189.     s_pClientDE = pClientDE;
  190.  
  191.  
  192.     // Set the static screen info...
  193.  
  194.     s_hScreen = pClientDE->GetScreenSurface();
  195.     if (!s_hScreen) return(DFALSE);
  196.  
  197.     pClientDE->GetSurfaceDims(s_hScreen, &s_dwScreenWidth, &s_dwScreenHeight);
  198.  
  199.  
  200.     // Figure out the font size we should use...
  201.  
  202.     int xFont = 8;
  203.     int yFont = 14;
  204.  
  205.     if (s_dwScreenWidth > 360)
  206.     {
  207.         xFont = 10;
  208.         yFont = 16;
  209.     }
  210.  
  211.     if (s_dwScreenWidth > 520)
  212.     {
  213.         xFont = 14;
  214.         yFont = 22;
  215.     }
  216.  
  217.  
  218.     // Set the static font info...
  219.  
  220.     HSTRING hstrFont = pClientDE->FormatString(IDS_CREDITSFONT);
  221.     if (hstrFont)
  222.     {
  223.         s_hFont = pClientDE->CreateFont(pClientDE->GetStringData(hstrFont), xFont, yFont, DFALSE, DFALSE, DFALSE);
  224.         pClientDE->FreeString (hstrFont);
  225.     }
  226.  
  227.     if (!s_hFont)
  228.     {
  229.         s_hFont = pClientDE->CreateFont("Arial", xFont, yFont, DFALSE, DFALSE, DFALSE);
  230.         if (!s_hFont) return(DFALSE);
  231.     }
  232.  
  233.     HSTRING hString = pClientDE->CreateString("Test");
  234.     if (!hString) return(DFALSE);
  235.  
  236.     int nTemp;
  237.     pClientDE->GetStringDimensions(s_hFont, hString, &nTemp, &s_nFontHeight);
  238.     pClientDE->FreeString(hString);
  239.  
  240.     s_nFontSpacing = 4;
  241.  
  242.  
  243.     // Set the default hold times base on the mode...
  244.  
  245.     if (nMode == CM_CREDITS)
  246.     {
  247.         s_fDefaultHoldTime = 4.0f;
  248.         s_fDefaultOutTime = 2.0f;
  249.     }
  250.  
  251.     if (nMode == CM_INTRO)
  252.     {
  253.         s_fDefaultHoldTime = 4.0f;
  254.         s_fDefaultOutTime  = 1.2f;
  255.     }
  256.  
  257.  
  258.     // Set the clear-screen flag...
  259.  
  260.     s_bClearScreen = bClearScreen;
  261.  
  262.  
  263.     // All done...
  264.  
  265.     return(DTRUE);
  266. }
  267.  
  268. void CCredit::TermStaticInfo()
  269. {
  270.     if (s_pClientDE && s_hFont)
  271.     {
  272.         s_pClientDE->DeleteFont(s_hFont);
  273.         s_hFont = NULL;
  274.     }
  275. }
  276.  
  277.  
  278. // ----------------------------------------------------------------------- //
  279. //
  280. //    ROUTINE:    CCredit::Draw
  281. //
  282. //    PURPOSE:    Draws all the strings of the credit
  283. //
  284. // ----------------------------------------------------------------------- //
  285.  
  286. void CCredit::Draw(int x, int y, HDECOLOR hForeColor)
  287. {
  288.     // Sanity checks...
  289.  
  290.     if (m_cStrings <= 0) return;
  291.  
  292.  
  293.     // Figure out where to start drawing...
  294.  
  295.     int nTotalHeight = (m_cStrings * (s_nFontHeight + s_nFontSpacing));
  296.     int yTop         = y - (nTotalHeight / 2);
  297.  
  298.  
  299.     // Draw each string...
  300.  
  301.     int yCur = yTop + ((s_nFontHeight + s_nFontSpacing) / 2);
  302.  
  303.     for (int i = 0; i < m_cStrings; i++)
  304.     {
  305.         HDECOLOR hBackColor = m_pClientDE->SetupColor2(0, 0, 0, DFALSE);
  306.         DrawString(GetString(i), hForeColor, hBackColor, x, yCur);
  307.         yCur += (s_nFontHeight + s_nFontSpacing);
  308.     }
  309. }
  310.  
  311. void CCredit::DrawString(HSTRING hString, HDECOLOR hForeColor, HDECOLOR hBackColor, int x, int y)
  312. {
  313.     // Sanity checks...
  314.  
  315.     if (!hString) return;
  316.  
  317.  
  318.     // Calculate the bounding rect of this string...
  319.  
  320.     int xString = 100;
  321.     int yString = 100;
  322.  
  323.     m_pClientDE->GetStringDimensions(s_hFont, hString, &xString, &yString);
  324.  
  325.     DRect rcDraw;
  326.  
  327.     rcDraw.left   = x - (xString / 2);
  328.     rcDraw.top    = y - (yString / 2);
  329.     rcDraw.right  = s_dwScreenWidth - 1;
  330.     rcDraw.bottom = s_dwScreenHeight - 1;
  331.  
  332.  
  333.     // Draw the string to the screen surface...
  334.  
  335.     if (!s_bClearScreen) hBackColor = SETRGB_T(0, 0, 0);
  336.  
  337.     m_pClientDE->DrawStringToSurface(s_hScreen, s_hFont, hString, &rcDraw, hForeColor, hBackColor);
  338. }
  339.  
  340.  
  341. // ----------------------------------------------------------------------- //
  342. //
  343. //    ROUTINE:    CCredit::Update
  344. //
  345. //    PURPOSE:    Updates the credit
  346. //
  347. //    RETURNS:    DFALSE = Stay with current credit
  348. //                DTRUE  = Advance to next credit
  349. //
  350. // ----------------------------------------------------------------------- //
  351.  
  352. DBOOL CCredit::Update()
  353. {
  354.     // Sanity checks...
  355.  
  356.     if (!m_pClientDE) return(DFALSE);
  357.  
  358.  
  359.     // Update based on our current state...
  360.  
  361.     switch(m_nState)
  362.     {
  363.         case CS_START:
  364.         {
  365.             SetState(CS_FADEIN);
  366.             return(DFALSE);
  367.         }
  368.  
  369.         case CS_FADEIN:
  370.         {
  371.             if (UpdateFadeIn())    SetState(CS_HOLDIN);
  372.             return(DFALSE);
  373.         }
  374.  
  375.         case CS_HOLDIN:
  376.         {
  377.             if (UpdateHoldIn()) SetState(CS_FADEOUT);
  378.             return(DFALSE);
  379.         }
  380.  
  381.         case CS_FADEOUT:
  382.         {
  383.             if (UpdateFadeOut()) SetState(CS_HOLDOUT);
  384.             return(DFALSE);
  385.         }
  386.  
  387.         case CS_HOLDOUT:
  388.         {
  389.             if (UpdateHoldOut()) SetState(CS_DONE);
  390.             return(DFALSE);
  391.         }
  392.  
  393.         case CS_DONE:
  394.         {
  395.             return(DTRUE);
  396.         }
  397.  
  398.         default:
  399.         {
  400.             return(DTRUE);
  401.         }
  402.     }
  403. }
  404.  
  405.  
  406. // ----------------------------------------------------------------------- //
  407. //
  408. //    ROUTINE:    CCredit::SetState
  409. //
  410. //    PURPOSE:    Sets the update state
  411. //
  412. // ----------------------------------------------------------------------- //
  413.  
  414. void CCredit::SetState(int nState)
  415. {
  416.     // Set the new state...
  417.  
  418.     m_nState = nState;
  419.  
  420.     switch (nState)
  421.     {
  422.         case CS_START:
  423.         {
  424.             break;
  425.         }
  426.  
  427.         case CS_FADEIN:
  428.         {
  429.             m_fTimer = 0.5f;
  430.             m_fColor = 0.0f;
  431.             break;
  432.         }
  433.  
  434.         case CS_HOLDIN:
  435.         {
  436.             m_fTimer = s_fDefaultHoldTime;
  437.             m_fColor = 1.0f;
  438.             if (m_fHoldTime > 0.0) m_fTimer = m_fHoldTime;
  439.             break;
  440.         }
  441.  
  442.         case CS_FADEOUT:
  443.         {
  444.             m_fTimer = 0.400f;
  445.             m_fColor = 1.0f;
  446.             break;
  447.         }
  448.  
  449.         case CS_HOLDOUT:
  450.         {
  451.             m_fTimer = s_fDefaultOutTime;
  452.             m_fColor = 1.0f;
  453.             break;
  454.         }
  455.  
  456.         case CS_DONE:
  457.         {
  458.             break;
  459.         }
  460.     }
  461.  
  462.     m_fTimerStart = m_fTimer;
  463.     m_fColorStart = m_fColor;
  464. }
  465.  
  466.  
  467. // ----------------------------------------------------------------------- //
  468. //
  469. //    ROUTINE:    CCredit::UpdateFadeIn
  470. //
  471. //    PURPOSE:    Updates the CS_FADEIN state
  472. //
  473. // ----------------------------------------------------------------------- //
  474.  
  475. DBOOL CCredit::UpdateFadeIn()
  476. {
  477.     // Update the timer value...
  478.  
  479.     DFLOAT fDelta = m_pClientDE->GetFrameTime();
  480.     fDelta *= CCredits::GetSpeed();
  481.     if (s_bPause) fDelta = 0;
  482.  
  483.     if (m_fTimer > fDelta)
  484.     {
  485.         m_fTimer -= fDelta;
  486.     }
  487.     else
  488.     {
  489.         m_fTimer = 0.0f;
  490.     }
  491.  
  492.  
  493.     // Update our color value...
  494.  
  495.     m_fColor = 1.0f - (m_fTimer / m_fTimerStart);
  496.  
  497.  
  498.     // Create the color stuff...
  499.  
  500.     if (m_fColor > 1.0f) m_fColor = 1.0f;
  501.  
  502.     HDECOLOR hColor = m_pClientDE->SetupColor1(m_fColor, 0, 0, DFALSE);
  503.  
  504.  
  505.     // Draw the credit...
  506.  
  507.     Draw(s_dwScreenWidth / 2, s_dwScreenHeight / 2, hColor);
  508.  
  509.  
  510.     // All done...
  511.  
  512.     return(m_fTimer == 0.0f);
  513. }
  514.  
  515.  
  516. // ----------------------------------------------------------------------- //
  517. //
  518. //    ROUTINE:    CCredit::UpdateHoldIn
  519. //
  520. //    PURPOSE:    Updates the CS_HOLDIN state
  521. //
  522. // ----------------------------------------------------------------------- //
  523.  
  524. DBOOL CCredit::UpdateHoldIn()
  525. {
  526.     // Update the timer value...
  527.  
  528.     DFLOAT fDelta = m_pClientDE->GetFrameTime();
  529.     fDelta *= CCredits::GetSpeed();
  530.     if (s_bPause) fDelta = 0;
  531.  
  532.     if (m_fTimer > fDelta)
  533.     {
  534.         m_fTimer -= fDelta;
  535.     }
  536.     else
  537.     {
  538.         m_fTimer = 0.0f;
  539.     }
  540.  
  541.  
  542.     // Create the color stuff...
  543.  
  544.     m_fColor = 1.0f;
  545.  
  546.     HDECOLOR hColor = m_pClientDE->SetupColor1(m_fColor, 0, 0, DFALSE);
  547.  
  548.  
  549.     // Draw the credit...
  550.  
  551.     Draw(s_dwScreenWidth / 2, s_dwScreenHeight / 2, hColor);
  552.  
  553.  
  554.     // All done...
  555.  
  556.     return(m_fTimer == 0.0f);
  557. }
  558.  
  559.  
  560. // ----------------------------------------------------------------------- //
  561. //
  562. //    ROUTINE:    CCredit::UpdateFadeOut
  563. //
  564. //    PURPOSE:    Updates the CS_FADEOUT state
  565. //
  566. // ----------------------------------------------------------------------- //
  567.  
  568. DBOOL CCredit::UpdateFadeOut()
  569. {
  570.     // Update the timer value...
  571.  
  572.     DFLOAT fDelta = m_pClientDE->GetFrameTime();
  573.     fDelta *= CCredits::GetSpeed();
  574.     if (s_bPause) fDelta = 0;
  575.  
  576.     if (m_fTimer > fDelta)
  577.     {
  578.         m_fTimer -= fDelta;
  579.     }
  580.     else
  581.     {
  582.         m_fTimer = 0.0f;
  583.     }
  584.  
  585.  
  586.     // Update our color value...
  587.  
  588.     m_fColor = m_fTimer / m_fTimerStart;
  589.  
  590.  
  591.     // Create the color stuff...
  592.  
  593.     if (m_fColor < 0.0f) m_fColor = 0.0f;
  594.     if (!s_bClearScreen && m_fColor < 0.1f)
  595.     {
  596.         m_fColor = 0.1f;
  597.         m_fTimer = 0.0f;
  598.     }
  599.  
  600.     HDECOLOR hColor = m_pClientDE->SetupColor1(m_fColor, 0, 0, DFALSE);
  601.  
  602.  
  603.     // Draw the credit...
  604.  
  605.     Draw(s_dwScreenWidth / 2, s_dwScreenHeight / 2, hColor);
  606.  
  607.  
  608.     // All done...
  609.  
  610.     return(m_fTimer == 0.0f);
  611. }
  612.  
  613.  
  614. // ----------------------------------------------------------------------- //
  615. //
  616. //    ROUTINE:    CCredit::UpdateHoldOut
  617. //
  618. //    PURPOSE:    Updates the CS_HOLDOUT state
  619. //
  620. // ----------------------------------------------------------------------- //
  621.  
  622. DBOOL CCredit::UpdateHoldOut()
  623. {
  624.     // Update the timer value...
  625.  
  626.     DFLOAT fDelta = m_pClientDE->GetFrameTime();
  627.     fDelta *= CCredits::GetSpeed();
  628.     if (s_bPause) fDelta = 0;
  629.  
  630.     if (m_fTimer > fDelta)
  631.     {
  632.         m_fTimer -= fDelta;
  633.     }
  634.     else
  635.     {
  636.         m_fTimer = 0.0f;
  637.     }
  638.  
  639.  
  640.     // All done...
  641.  
  642.     return(m_fTimer == 0.0f);
  643. }
  644.  
  645.  
  646. // ----------------------------------------------------------------------- //
  647. //
  648. //    ROUTINE:    CCredits::Init
  649. //
  650. //    PURPOSE:    Initialization
  651. //
  652. // ----------------------------------------------------------------------- //
  653.  
  654. DBOOL CCredits::Init(CClientDE* pClientDE, CBloodClientShell* pClientShell, int nMode, DBOOL bClearScreen)
  655. {
  656.     // Sanity checks...
  657.  
  658.     if (!pClientDE) return(DFALSE);
  659.     if (!pClientShell) return(DFALSE);
  660.  
  661.     Term();
  662.  
  663.  
  664.     // Set simple members...
  665.  
  666.     m_pClientDE    = pClientDE;
  667.     m_pClientShell = pClientShell;
  668.     m_iCredit      = 0;
  669.     m_nMode        = nMode;
  670.     m_bDone        = DFALSE;
  671.     m_bClearScreen = bClearScreen;
  672.     s_fSpeed       = DEF_CREDITS_SPEED;
  673.  
  674.  
  675.     // Init the screen size...
  676.  
  677.     m_hScreen = m_pClientDE->GetScreenSurface();
  678.     if (!m_hScreen) return(DFALSE);
  679.  
  680.     m_pClientDE->GetSurfaceDims(m_hScreen, &m_szScreen.cx, &m_szScreen.cy);
  681.  
  682.  
  683.     // Add all the credit objects...
  684.  
  685.     AddCredits();
  686.  
  687.  
  688.     // All done...
  689.  
  690.     m_bInited = DTRUE;
  691.  
  692.     return(DTRUE);
  693. }
  694.  
  695.  
  696. // ----------------------------------------------------------------------- //
  697. //
  698. //    ROUTINE:    CCredits::Term
  699. //
  700. //    PURPOSE:    Termination
  701. //
  702. // ----------------------------------------------------------------------- //
  703.  
  704. void CCredits::Term()
  705. {
  706.     // Term all the credits...
  707.  
  708.     for (int i = 0; i < MAX_CREDITS; i++)
  709.     {
  710.         CCredit* pCredit = GetCredit(i);
  711.         if (pCredit) pCredit->Term();
  712.     }
  713.  
  714.  
  715.     // Clear all members...
  716.  
  717.     CCredit::TermStaticInfo();
  718.  
  719.     Clear();
  720. }
  721.  
  722.  
  723. // ----------------------------------------------------------------------- //
  724. //
  725. //    ROUTINE:    CCredits::HandleInput
  726. //
  727. //    PURPOSE:    Handler for input
  728. //
  729. // ----------------------------------------------------------------------- //
  730.  
  731. void CCredits::HandleInput(int vkey)
  732. {
  733.     // Handle various kes...
  734.  
  735.     switch (vkey)
  736.     {
  737.         case VK_UP:
  738.         {
  739.             if (IsIntro()) break;
  740.             IncSpeed();
  741.             break;
  742.         }
  743.  
  744.         case VK_DOWN:
  745.         {
  746.             if (IsIntro()) break;
  747.             DecSpeed();
  748.             break;
  749.         }
  750.  
  751.         case VK_HOME:
  752.         {
  753.             if (IsIntro()) break;
  754.             s_fSpeed = 1.0;
  755.             break;
  756.         }
  757.  
  758.         case VK_RETURN:
  759.         case VK_SPACE:
  760.         case VK_NEXT:
  761.         {
  762.             if (IsIntro())
  763.             {
  764.                 CCredit* pCredit = GetCredit(m_iCredit);
  765.                 if (pCredit)
  766.                 {
  767.                     if (pCredit->GetState() == CS_HOLDIN)
  768.                     {
  769.                         pCredit->SetState(CS_FADEOUT);
  770.                     }
  771.                 }
  772.             }
  773.             else
  774.             {
  775.                 AdvanceCredit(CS_HOLDIN);
  776.             }
  777.             break;
  778.         }
  779.  
  780.         case VK_PAUSE:
  781.         {
  782.             if (IsIntro()) break;
  783.             s_bPause ^= 1;
  784.             break;
  785.         }
  786.  
  787.         case VK_ESCAPE:
  788.         {
  789.             ExitToMainMenu();
  790.             break;
  791.         }
  792.     }
  793. }
  794.  
  795.  
  796. // ----------------------------------------------------------------------- //
  797. //
  798. //    ROUTINE:    CCredits::ExitToMainMenu
  799. //
  800. //    PURPOSE:    Exits back to the main menu game state
  801. //
  802. // ----------------------------------------------------------------------- //
  803.  
  804. void CCredits::ExitToMainMenu()
  805. {
  806.     m_bDone = DTRUE;
  807. }
  808.  
  809.  
  810. // ----------------------------------------------------------------------- //
  811. //
  812. //    ROUTINE:    CCredits::Update
  813. //
  814. //    PURPOSE:    Updates the credits
  815. //
  816. // ----------------------------------------------------------------------- //
  817.  
  818. void CCredits::Update()
  819. {
  820.     // Sanity checks...
  821.  
  822.     if (!m_pClientDE) return;
  823.     if (m_cCredits <= 0) return;
  824.  
  825.  
  826.     // Clear the screen...
  827.  
  828.     if (m_bClearScreen)
  829.     {
  830.         m_pClientDE->ClearScreen(NULL, CLEARSCREEN_SCREEN);
  831.     }
  832.  
  833.  
  834.     // Update the current credit...
  835.  
  836.     CCredit* pCredit = GetCredit(m_iCredit);
  837.     if (!pCredit) return;
  838.  
  839.     if (pCredit->Update())
  840.     {
  841.         AdvanceCredit();
  842.     }
  843. }
  844.  
  845. void CCredits::AdvanceCredit(int nState)
  846. {
  847.     m_iCredit++;
  848.     if(m_iCredit >= m_cCredits)
  849.     {
  850.         m_iCredit = 0;
  851.         if (IsIntro()) m_bDone = DTRUE;
  852.     }
  853.     CCredit* pCredit = GetCredit(m_iCredit);
  854.     if (pCredit) pCredit->SetState(nState);
  855. }
  856.  
  857.  
  858. // ----------------------------------------------------------------------- //
  859. //
  860. //    ROUTINE:    CCredits::DrawCenteredString
  861. //
  862. //    PURPOSE:    Draws the given string centered at the give coord
  863. //
  864. // ----------------------------------------------------------------------- //
  865.  
  866. void CCredits::DrawCenteredStringToScreen(HDEFONT hFont, HSTRING hString, HDECOLOR hForeColor, HDECOLOR hBackColor, int xDraw, int yDraw)
  867. {
  868.     // Sanity checks...
  869.  
  870.     if (!hFont) return;
  871.     if (!hString) return;
  872.  
  873.  
  874.     // Calculate the bounding rect of this string...
  875.  
  876.     int xString = 100;
  877.     int yString = 100;
  878.  
  879.     m_pClientDE->GetStringDimensions(hFont, hString, &xString, &yString);
  880.  
  881.     DRect rcDraw;
  882.  
  883.     rcDraw.left   = xDraw - (xString / 2);
  884.     rcDraw.top    = yDraw - (yString / 2);
  885.     rcDraw.right  = m_szScreen.cx - 1;
  886.     rcDraw.bottom = m_szScreen.cy - 1;
  887.  
  888.  
  889.     // Draw the string to the screen surface...
  890.  
  891.     if (!m_bClearScreen) hBackColor = SETRGB_T(0, 0, 0);
  892.  
  893.     m_pClientDE->DrawStringToSurface(m_hScreen, hFont, hString, &rcDraw, hForeColor, hBackColor);
  894. }
  895.  
  896.  
  897. // ----------------------------------------------------------------------- //
  898. //
  899. //    ROUTINE:    CCredits::AddCredits
  900. //
  901. //    PURPOSE:    Adds all the credit objects
  902. //
  903. // ----------------------------------------------------------------------- //
  904.  
  905. void CCredits::AddCredits()
  906. {
  907.     // Sanity checks...
  908.  
  909.     if (!m_pClientDE) return;
  910.  
  911.  
  912.     // Set the static info...
  913.  
  914.     if (!CCredit::SetStaticInfo(m_pClientDE, GetMode(), IsClearingScreen()))
  915.     {
  916.         return;
  917.     }
  918.  
  919.  
  920.     // Get the credits text buffer...
  921.  
  922.     char* sName = NULL;
  923.  
  924. #ifdef _ADDON
  925.     if (IsIntro()) sName = "INTRO_AO";
  926.     else sName = "CREDITS_AO";
  927. #else
  928.     if (IsIntro()) sName = "INTRO";
  929.     else sName = "CREDITS";
  930. #endif
  931.  
  932.     void* hModule = NULL;
  933.     m_pClientDE->GetEngineHook("cres_hinstance", &hModule);
  934.  
  935.     char* sBuf = CreditsWin_GetTextBuffer(sName, hModule);
  936.     if (!sBuf) return;
  937.  
  938.  
  939.     char sCredit[1024];
  940.     int  i = 0;
  941.  
  942.     while (*sBuf)
  943.     {
  944.  
  945.         if (*sBuf == '#' && *((char*)_mbsinc((const unsigned char*)sBuf)) == '#')
  946.         {
  947.             sCredit[i] = '\0';
  948.  
  949.             if (_mbsnbcmp((const unsigned char*)sCredit, (const unsigned char*)">END", 4) == 0)    // end?
  950.             {
  951.                 return;
  952.             }
  953.  
  954.             AddCredit(sCredit);
  955.             i = 0;
  956.  
  957.             sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
  958.             sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
  959.  
  960.             while (*sBuf != '\0' && ((*sBuf == '\n') || (*sBuf == '\r'))) sBuf++;
  961.         }
  962.         else
  963.         {
  964.             int nCount = _mbsnbcnt((const unsigned char*)sBuf,1);
  965.             memcpy(&sCredit[i], sBuf, nCount);
  966.             i += nCount;
  967.             sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
  968.         }
  969.     }
  970. }
  971.  
  972. void CCredits::AddCredit(char* sText)
  973. {
  974.     // Sanity checks...
  975.  
  976.     if (!m_pClientDE) return;
  977.  
  978.  
  979.     // Add the credit...
  980.  
  981.     CCredit* pCredit = GetCredit(m_cCredits);
  982.     if (!pCredit) return;
  983.  
  984.     if (!pCredit->Init(m_pClientDE, sText)) return;
  985.  
  986.  
  987.     // Inc our credit counter...
  988.  
  989.     m_cCredits++;
  990. }
  991.  
  992.  
  993.  
  994.  
  995.  
  996.